#							-*- shell-script -*-
#
# Copyright by The HDF Group.
# All rights reserved.
#
# This file is part of HDF5.  The full HDF5 copyright notice, including
# terms governing use, modification, and redistribution, is contained in
# the COPYING file, which can be found at the root of the source code
# distribution tree, or in https://www.hdfgroup.org/licenses.
# If you do not have access to either file, you may request a copy from
# help@hdfgroup.org.


# This file is part of the HDF5 build script.  It is processed shortly
# after configure starts and defines, among other things, flags for
# the various compile modes.
#
# See BlankForm in this directory for details.

# The default compiler is `gcc'.
if test -z "$CC"; then
    if test "X-$enable_parallel" = "X-yes"; then
	# default to use mpicc which is the defacto MPI compiler name
	CC=mpicc
	CC_BASENAME=mpicc
    else
	CC=gcc
	CC_BASENAME=gcc
    fi
fi

# Figure out GNU C compiler flags
. $srcdir/config/gnu-flags

# Figure out PGI C compiler flags
. $srcdir/config/pgi-flags

# Figure out CCE C compiler flags
. $srcdir/config/cce-flags

# Figure out Intel oneAPI C compiler flags
. $srcdir/config/oneapi-flags

# Figure out Intel classic C compiler flags
. $srcdir/config/intel-flags

# Figure out Clang C compiler flags
. $srcdir/config/clang-flags

# Figure out NVHPC C compiler flags
. $srcdir/config/nvidia-flags

# Use default Fortran 90 compiler according to what C compiler is used.
if test "X-" = "X-$FC"; then
    case $CC_BASENAME in
        gcc*)
            FC=gfortran
            FC_BASENAME=gfortran
            ;;
        pgcc*)
            FC=pgf90
            FC_BASENAME=pgf90
            ;;
        nvc*)
            FC=nvfortran
            FC_BASENAME=nvfortran
            ;;
        icx*)
            FC=ifx
            FC_BASENAME=ifx
            ;;
        icc*)
            FC=ifort
            FC_BASENAME=ifort
            ;;
        mpicc*)
            FC=mpif90
            FC_BASENAME=mpif90
            ;;
        clang*)
            # clang has no fortran compiler. Use gfortran.
            FC=gfortran
            FC_BASENAME=gfortran
            ;;
    esac
else
    case $FC in
        # The PGI and Intel compilers are automatically detected below
        ifc*|ifort*|pgf90*|nvfortran*)
            ;;

        *f95*)
            # Figure out which compiler we are using: pgf90 or Absoft f95
            RM='rm -f'
            tmpfile=/tmp/cmpver.$$
            $FC -V >$tmpfile
            if test -s "$tmpfile"; then 
                if( grep -s 'Absoft' $tmpfile > /dev/null) then
                    FC_BASENAME=f95
                fi 
                if( grep -s 'pgf90' $tmpfile > /dev/null) then
                    FC_BASENAME=pgf90
                fi 
            fi
            $RM $tmpfile
            fc_version_info=`$FC -V | grep Absoft`
            ;;
         # The NAG compiler
	 *nagfor*|*nagftn*)
            RM='rm -f'
            tmpfile=/tmp/cmpver.$$
            $FC -V >& $tmpfile
            if test -s "$tmpfile"; then
                if( grep -s 'NAG Fortran' $tmpfile > /dev/null) then
                    FC_BASENAME=nagfor
                fi
            fi
            fc_version_info=`grep "NAG Fortran" $tmpfile`
            echo "compiler '$FC' is $fc_version_info"
            $RM $tmpfile
	    ;;
         *)
            ;;
    esac
fi

# Figure out GNU FC compiler flags
. $srcdir/config/gnu-fflags

# Figure out PGI FC compiler flags
. $srcdir/config/pgi-fflags

# Figure out CCE FC compiler flags
. $srcdir/config/cce-fflags

# Figure out Intel oneAPI FC compiler flags
. $srcdir/config/oneapi-fflags

# Figure out Intel classic FC compiler flags
. $srcdir/config/intel-fflags

# Figure out Clang FC compiler flags
. $srcdir/config/clang-fflags

# Figure out NVHPC FC compiler flags
. $srcdir/config/nvidia-fflags

case $FC_BASENAME in
    #
    # Absoft compiler
    #
    f95)
        # Set required flag for compiling C stubs
        H5_CFLAGS="$H5_CFLAGS"

        F9XSUFFIXFLAG=""
        H5_FCFLAGS="$H5_FCFLAGS"
        FSEARCH_DIRS=""

        # Production
        PROD_FCFLAGS=

        # Debug
        DEBUG_FCFLAGS=

        # Symbols
        SYMBOLS_FCFLAGS="-g"
        NO_SYMBOLS_FCFLAGS="-s"

        # Profiling
        PROFILE_FCFLAGS="-pg"

        # Optimization
        HIGH_OPT_FCFLAGS="-O"
        DEBUG_OPT_FCFLAGS=
        NO_OPT_FCFLAGS=

        f9x_flags_set=yes
        ;;
#
#   NAG compiler
#
    nagfor)

        F9XSUFFIXFLAG=""
        AM_FCFLAGS="$AM_FCFLAGS"
        FSEARCH_DIRS=""

        # Production
        PROD_FCFLAGS=

        # Debug
        DEBUG_FCFLAGS="-C"

        # Symbols
        SYMBOLS_FCFLAGS="-g"
        NO_SYMBOLS_FCFLAGS="-s"

        # Profiling
        PROFILE_FCFLAGS="-pg"

        # Optimization
        HIGH_OPT_FCFLAGS="-O"
        DEBUG_OPT_FCFLAGS="-O0"
        NO_OPT_FCFLAGS="-O0"

        f9x_flags_set=yes
        ;;

esac  

# The default C++ compiler

# The default compiler is `g++'.
if test -z "$CXX"; then
  CXX=g++
  CXX_BASENAME=g++
fi

# Figure out Intel oneAPI CXX compiler flags
. $srcdir/config/oneapi-cxxflags

# Figure out Intel classic CXX compiler flags
# Do this ahead of GNU to avoid icpc being detected as g++
. $srcdir/config/intel-cxxflags

# Figure out GNU CXX compiler flags
. $srcdir/config/gnu-cxxflags

# Figure out PGI CXX compiler flags
. $srcdir/config/pgi-cxxflags

# Figure out Clang CXX compiler flags
. $srcdir/config/clang-cxxflags

# Figure out NVHPC CXX compiler flags
. $srcdir/config/nvidia-cxxflags

# compiler version strings

# check if the compiler_version_info is already set
if test -z "$cc_version_info"; then

case $CC in
    # whatever matches *pgcc* will also match *gcc*, so this one must come first
    *pgcc*)
        cc_version_info=`$CC $CFLAGS $H5_CFLAGS -V 2>&1 | grep 'pgcc'`
        ;;

    *gcc*)
        cc_version_info=`$CC $CFLAGS $H5_CFLAGS --version 2>&1 | grep -v 'PathScale' |\
            grep 'GCC' | sed 's/\(.*(GCC) [-a-z0-9\. ]*\).*/\1/'`
        ;;
    # this must come before *icc* for the same reason
    *mpicc*)
        cc_version_info=`$CC $CCFLAGS $H5_CCFLAGS -v 2>&1 | grep 'version' |\
            sed 's/^[a-z0-9]* for //' |\
            sed 's/\"/\\\"/g' |\
            sed 's/^\([a-z]* \)/ built with \1/1'`
        cc_version_info=`echo $cc_version_info`
        ;;

    *nvc*)
        cc_version_info=`$CC $CFLAGS $H5_CFLAGS -V 2>&1 | grep 'nvc'`
        ;;

    *icx*)
        cc_version_info=`$CC $CCFLAGS $H5_CCFLAGS -V 2>&1 | grep 'Version' |\
            sed 's/\(Intel.* Compiler\).*\( Version [a-z0-9\.]*\).*\( Build [0-9]*\)/\1\2\3/'`
        ;;

    *icc*)
        cc_version_info=`$CC $CCFLAGS $H5_CCFLAGS -V 2>&1 | grep 'Version' |\
            sed 's/\(Intel.* Compiler\).*\( Version [a-z0-9\.]*\).*\( Build [0-9]*\)/\1\2\3/'`
        ;;

    *clang*)
        cc_version_info="`$CC $CFLAGS $H5_CFLAGS --version 2>&1 |\
            grep 'clang version' | sed 's/.*clang version \([-a-z0-9\.]*\).*/\1/'`"
        ;;

    *)
        echo "No match to get cc_version_info for $CC"
        ;;
esac

fi

# get fortran version info
# check if the compiler_version_info is already set
if test -z "$fc_version_info"; then
case $FC in
    *gfortran*)
        fc_version_info=`$FC $FCFLAGS $H5_FCFLAGS --version 2>&1 |\
            grep 'GCC' | sed 's/\(.*(GCC) [-a-z0-9\. ]*\).*/\1/'`
        ;;

    *mpif90*)
        fc_version_info=`$FC $FCFLAGS $H5_FCFLAGS -v 2>&1 | grep 'version' |\
            sed 's/^[a-z0-9]* for //' |\
            sed 's/\"/\\\"/g' |\
            sed 's/^\([a-z]* \)/ built with \1/1'`
        fc_version_info=`echo $fc_version_info`
        ;;

    *ifx*)
        fc_version_info=`$FC $FCFLAGS $H5_FCFLAGS -V 2>&1 | grep 'Version' |\
            sed 's/\(Intel.* Compiler\).*\( Version [a-z0-9\.]*\).*\( Build [0-9]*\)/\1\2\3/'`
        ;;

    *ifc*|*ifort*)
        fc_version_info=`$FC $FCFLAGS $H5_FCFLAGS -V 2>&1 | grep 'Version' |\
            sed 's/\(Intel.* Compiler\).*\( Version [a-z0-9\.]*\).*\( Build [0-9]*\)/\1\2\3/'`
        ;;

    *f95*)
        # Figure out which compiler we are using: pgf90 or Absoft f95
        RM='rm -f'
        tmpfile=/tmp/cmpver.$$
        $FC -V >$tmpfile
        if test -s "$tmpfile"; then 
            if( grep -s 'Absoft' $tmpfile > /dev/null) then
                FC_BASENAME=f95
            fi 
        fi
        $RM $tmpfile
        fc_version_info=`$FC -V | grep Absoft`
        ;;

    *g95*)
        fc_version_info=`$FC $FCFLAGS $H5_FCFLAGS --version 2>&1 |\
            grep 'GCC'` 
        ;;

    *pgf90*)
        fc_version_info=`$FC $FCFLAGS $H5_FCFLAGS -V 2>&1 | grep 'pgf90'`
        ;;

    *nvfortran*)
        fc_version_info=`$FC $FCFLAGS $H5_FCFLAGS -V 2>&1 | grep 'nvfortran'`
        ;;

    *nagfor*|*nagftn*)
        RM='rm -f'
        tmpfile=/tmp/cmpver.$$
        $FC -V >& $tmpfile
        if test -s "$tmpfile"; then
           if( grep -s 'NAG Fortran' $tmpfile > /dev/null) then
               FC_BASENAME=nagfor
           fi
        fi
        fc_version_info=`grep "NAG Fortran" $tmpfile`
        $RM $tmpfile
        echo "compiler '$FC' is $fc_version_info"
	;;

     *)
        echo "No match to get fc_version_info for $FC"
        ;;
esac
fi

# get c++ version info
# check if the compiler_version_info is already set
if test -z "$cxx_version_info"; then
case $CXX in
    *nvc++*)
        cxx_version_info=`$CXX $CXXFLAGS $H5_CXXFLAGS -V 2>&1 | grep 'nvc++'`
        ;;
    *pgc++*)
        cxx_version_info=`$CXX $CXXFLAGS $H5_CXXFLAGS -V 2>&1 | grep 'pgc++'`
        ;;
    *g++*)
        cxx_version_info=`$CXX $CXXFLAGS $H5_CXXFLAGS --version 2>&1 |\
            grep 'GCC' | sed 's/\(.*(GCC) [-a-z0-9\. ]*\).*/\1/'`
        ;;
    *icpx*)
        cxx_version_info=`$CXX $CXXFLAGS $H5_CXXFLAGS -V 2>&1 | grep 'Version' |\
            sed 's/\(Intel.* Compiler\).*\( Version [a-z0-9\.]*\).*\( Build [0-9]*\)/\1\2\3/'`
        ;;
    *icpc*)
        cxx_version_info=`$CXX $CXXFLAGS $H5_CXXFLAGS -V 2>&1 | grep 'Version' |\
            sed 's/\(Intel.* Compiler\).*\( Version [a-z0-9\.]*\).*\( Build [0-9]*\)/\1\2\3/'`
        ;;
    *mpicxx*)
        cxx_version_info=`$CXX $CXXFLAGS $H5_CXXFLAGS -v 2>&1 | grep 'version' |\
            sed 's/^[a-z0-9]* for //' |\
            sed 's/^\([a-z]* \)/ built with \1/1'`
        cxx_version_info=`echo $cxx_version_info`
        ;; 

    *clang++*)
        cxx_version_info="`$CXX $CXXFLAGS $H5_CXXFLAGS --version 2>&1 |\
            grep 'clang version' | sed 's/.*clang version \([-a-z0-9\.]*\).*/\1/'`"
        ;;

    *)
        echo "No match to get cxx_version_info for $CXX"
        ;;
esac
fi
